home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / bbs / diebox19 / send.c < prev    next >
Text File  |  1992-08-15  |  35KB  |  1,518 lines
  1. /*                    impmsg.c                 */
  2. #define                       VERSION "1.4"
  3. /*                          DL6HAZ Jul. 1992
  4. *             compiliert mit TC 1.5 - huge, Warnings off
  5. *                  All Warnings ON = 108 - normal
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <time.h>
  11. #include <string.h>
  12. #include <fcntl.h>
  13. #include <errno.h>
  14. #include <stdlib.h>
  15. #include <ctype.h>
  16. #include <dir.h>
  17. #include <dos.h>
  18. #include <sys\stat.h>
  19.  
  20. /*#define DEBUG  */          /* es werden auch keine tmpfiles geloescht */
  21. /*#define KEYB   */          /* ermoeglich eingaben fast wie  bei einem  */
  22.              /* sendbefehl ueber die Tastur */
  23.  
  24. #define ShowLength 87
  25. #define IDXLENGTH 115                   /* protfile */
  26. #define BoxNullTime 536454000L         /*01.01.87*/
  27. #define SFLength 104
  28.  
  29.  
  30. #define AEXISTS 00              /* es stellt sich die Frage warum */
  31.                       /* wenn es access gibt, nicht die */
  32.                       /* entsprechenden #define gibt ...*/
  33.  
  34.  
  35. char *GetMsg();
  36. char *GetDest();
  37. char *genBullID();
  38. char *upcase();
  39. char *lcase();
  40. char *ConvName();
  41. char *getpath();
  42. char *getenv();
  43. long GetMaxBytes();
  44. unsigned long absDat();
  45. struct userrec *readUSRInfo();
  46. struct userindex *getIndex();
  47. struct SF_DIR *get_mb();
  48.  
  49.  
  50. extern char *sys_errlist[];
  51. extern long timezone = 0l;
  52. extern int daylight = 0;
  53. extern int _fmode;
  54.  
  55. int err_count = 0;
  56. int BinFlag = 0;
  57. long glob_bytecount = 0l;
  58.  
  59. unsigned char MultiBuff[10240];
  60. unsigned crctab[256];
  61.  
  62. struct userindex {
  63.         char call[8];
  64.         unsigned long pos;
  65.           };
  66.  
  67. struct userrec {
  68.         char Language[4];
  69.         char LastLogin[15];
  70.         char MyBBS[7];
  71.         char Name[16];
  72.         int Status;
  73.         unsigned long ltime;
  74.           };
  75.  
  76. struct SF_DIR {
  77.                 int pos;
  78.         char mb[10];
  79.           };
  80.  
  81.  
  82. main(argc, argv)
  83. int argc;
  84. char *argv[];
  85. {
  86. int priv;
  87. int lifetime;
  88. int FileCount = 0;
  89. char Call[80];
  90. char Dest[80];
  91. char Subject[80];
  92. char Language[5];
  93. char BullID[20];
  94. char ImpPath[MAXPATH];
  95. long pos;
  96. long len;
  97.  
  98.  
  99.  
  100. FILE *imp_fp;
  101.  
  102. /*
  103. putenv("MBSYS_DIR=D:\\MB_TEST\\MBSYS\\");
  104. putenv("USR_DIR=D:\\MB_TEST\\USR\\");
  105. putenv("INFO_DIR=D:\\MB_TEST\\INFO\\");
  106.   */
  107.  
  108. /* Defaultwerte einstellen */
  109. memset(Dest, '\0', sizeof(Dest));
  110. memset(Subject, '\0', sizeof(Subject));
  111. memset(BullID, '\0', sizeof(BullID));
  112. memset(Call, '\0',  sizeof(Call));
  113. sprintf(Language, "%s", getenv("DEFAULT_LANG"));
  114. upcase(Language);
  115. priv = 1;
  116. lifetime = 32000;
  117. BinFlag = 0;
  118.  
  119. fclose(stdprn);
  120. fclose(stdaux);
  121. #ifndef KEYB
  122.   fprintf(stdout, "                              IMPMSG\n");
  123. #endif
  124.  
  125. #ifdef KEYB
  126.   fprintf(stdout, "                               SEND\n");
  127. #endif
  128.  
  129.  
  130. fprintf(stdout, "                            Version %s\n", VERSION);
  131. fprintf(stdout, "                            %s\n\n", __DATE__);
  132.  
  133. #ifndef KEYB
  134.   fprintf(stdout, "                 Import-Utilitie for THEBOX 1.9\n");
  135.   fprintf(stdout, "                     for Text- or BinFiles!\n");
  136.   fprintf(stdout, "          For HELP call IMPMSG without any Arguments!\n");
  137. #endif
  138.  
  139.  
  140. #ifdef DEBUG
  141.   fprintf(stderr, "\n*** DEBUG-MODE ***\n");
  142. #endif
  143.  
  144. init_crctab();
  145. #ifndef KEYB
  146.   if(argc >1){
  147.     fprintf(stdout, "\nImport: %s\n\n", argv[1]);
  148.         if((imp_fp = fopen(argv[1], "rt")) == NULL){
  149.         fprintf(stderr, "%s ", argv[1]);
  150.         perror("Importfile");
  151.         exit(1);
  152.     }
  153.     setvbuf(imp_fp, NULL, _IOFBF, 10240);
  154.     sprintf(ImpPath, "%s", getpath(argv[1]));
  155.     sprintf(Call, "%s", getenv("OWNBBS"));
  156.         upcase(Call);
  157.     fseek(imp_fp, 0l, 2);
  158.     len = ftell(imp_fp);
  159.     fseek(imp_fp, 0l, 0);
  160.     if(*Call != '\0')
  161.     do{
  162.        SendRoutine(
  163.           Call, Dest, Subject,  BullID, lifetime, Language, priv, imp_fp, ImpPath);
  164.        memset(Dest, '\0', sizeof(Dest));
  165.        memset(Subject, '\0', sizeof(Subject));
  166.        memset(BullID, '\0', sizeof(BullID));
  167.            BinFlag = 0;
  168.        lifetime = 32000;
  169.        pos = ftell(imp_fp);
  170.        FileCount++;
  171.       } while(len > pos+10);
  172.     fclose(imp_fp);
  173.         fprintf(stdout,
  174.         "\n\nImport OK!\nMsg: %d  Bytes: %ld  Errors: %d\n\n",
  175.                                   FileCount,
  176.                                   glob_bytecount,
  177.                                   err_count);
  178.   }
  179.   else
  180.     help();
  181. #endif
  182.  
  183. #ifdef KEYB
  184.  sprintf(Call, "%s", getenv("OWNBBS"));
  185.  upcase(Call);
  186.  if(*Call != '\0')
  187.   SendRoutine(Call, Dest, Subject,  BullID, lifetime, Language, priv, stdin, ImpPath);
  188. #endif
  189. }
  190.  
  191.  
  192.  
  193. SendRoutine(Call, Dest, Subject, BullID, lifetime, Lang, priv, Imp_fp, ImpPath)
  194. unsigned char *Call;
  195. unsigned char *Dest;
  196. unsigned char *Subject;
  197. char *BullID;
  198. int lifetime;
  199. char *Lang;
  200. int priv;
  201. FILE *Imp_fp;
  202. char *ImpPath;
  203. {
  204. char cmd[10];
  205. char ZielMB[80];
  206. char ChanStr[100];
  207. char SaveDir[80];
  208. char TmpFilename[80];
  209. char OrgSName[20];
  210. char BoxSName[20];
  211. char SendCall[20];
  212. char RecFrom[10];
  213. char *opt_ptr;
  214. char ShowRec[ShowLength+1];
  215. char *ptr;
  216. char c;
  217. long bytecount = 0l;
  218. unsigned bytes;
  219. int get_text();
  220. int LifetimeBox;
  221. int No;
  222. int i;
  223. long fp_pos;
  224. time_t utc_secs;
  225.  
  226. struct tm *utc;
  227. struct userrec *Record;
  228. struct stat Stat;
  229.  
  230.  
  231. FILE *Tmp_fp;
  232. FILE *fp;
  233. FILE *Prot_fp;
  234.  
  235. #ifndef KEYB
  236.    *cmd = '\0';
  237.    fscanf(Imp_fp, "%s", cmd);
  238.    lcase(cmd);
  239.    if((strncmp(cmd, "send", strlen(cmd))) != 0){
  240.     fprintf(stderr, "%s %s", cmd, GetMsg(21, Lang));
  241.     exit(1);
  242.    }
  243. #endif
  244.  
  245.  
  246. if(*Dest == '\0'){
  247.     fprintf(stderr, "\n%s\n", GetMsg(16, Lang));
  248.     fgets(Dest, 80, Imp_fp);
  249.     if(*Dest == '\n'){
  250.         fprintf(stderr, "%s\n", GetMsg(3, Lang));
  251.         exit(1);
  252.     }
  253.        *(Dest+strlen(Dest)-1) = '\0';
  254. }
  255. if(*Subject == '\0'){
  256.     fprintf(stderr, "%s\n", GetMsg(17, Lang));
  257.     fgets(Subject, 80, Imp_fp);
  258.     if(*Subject == '\n'){
  259.         fprintf(stderr, "%s\n", GetMsg(3, Lang));
  260.         exit(1);
  261.     }
  262.         *(Subject +strlen(Subject)-1) = '\0';
  263. }
  264. upcase(Dest);
  265. /* text in tmp-file abspeichern */
  266. sprintf(ChanStr, "%sboxXXXXXX", getenv("TMP_DIR"));
  267. sprintf(TmpFilename, "%s",  mktemp(ChanStr));
  268. if((Tmp_fp=fopen(TmpFilename, "w")) == NULL){
  269.      fprintf(stderr, "%s ", TmpFilename);
  270.      perror("Tmpfile");
  271.      exit(1);
  272. }
  273. /* msg-headline erstellen, vorbereiten */
  274. if((ptr = strchr(Dest, '@')) > NULL){   /* aufteilen nach Filename, ZielMb*/
  275.    *ptr = '\40';
  276.    sscanf(Dest, "%s %s", OrgSName, ZielMB);
  277. }
  278. else{
  279.    *ZielMB = '\0';
  280.    sscanf(Dest, "%s", OrgSName);
  281. }
  282. sprintf(SendCall, "%.6s", Call);
  283. /* find and interpre Options */
  284.    ptr = &Dest[0]+strlen(ZielMB) + strlen(OrgSName);
  285.    if(ptr != NULL) ptr++;
  286.    if((opt_ptr = strchr(ptr, '#')) != NULL){
  287.     sscanf((opt_ptr+1), "%3d", &lifetime);
  288.     }
  289.     if((opt_ptr = strchr(ptr, '$')) != NULL){
  290.     sscanf((opt_ptr+1), "%13s", BullID);
  291.     }
  292.     if((opt_ptr = strchr(ptr, '<')) != NULL){
  293.         sscanf((opt_ptr+1), "%6s", SendCall);
  294.     if(isCall(SendCall) == 0)
  295.           sprintf(SendCall, "%s", Call);
  296.     }
  297.  
  298. if((ptr= ConvName(Dest)) == NULL)        /* FileName evt convertieren */
  299.    sprintf(BoxSName, "%s", OrgSName);
  300. else
  301.    sprintf(BoxSName, "%s", ptr);
  302. #ifdef DEBUG
  303. fprintf(stderr,
  304. "\n-----------------------------------------------------------------------\n");
  305. fprintf(stderr, "Zeile %d:\n", __LINE__);
  306. fprintf(stderr,
  307.     "Call   : %-6s SendCall : %-6s BoxSn : %-8s OrgSn    : %-8s\n",
  308.                             Call,
  309.                         SendCall,
  310.                         BoxSName,
  311.                         OrgSName);
  312. fprintf(stderr, "ZielMB : %-6s BullID   : %-13s           lifetime : %-4d\n",
  313.                                 ZielMB,
  314.                                 BullID,
  315.                                 lifetime);
  316. fprintf(stderr,
  317. "-----------------------------------------------------------------------\n");
  318. #endif
  319. if(isCall(BoxSName) == 0){                  /* InfoFile */
  320.     if(*ZielMB == '\0')
  321.             sprintf(ZielMB,"%-.8s",getenv("DEF_SF"));
  322.     if(*BullID == '\0')
  323.         sprintf(BullID, "%s", genBullID());
  324.     LifetimeBox  = getLifetime(BoxSName);
  325.     if(lifetime != 32000){
  326.           ptr = getenv("LF_FLAG");
  327.         switch(*ptr){
  328.             case '0': LifetimeBox = lifetime;
  329.                   break;
  330.             case '1': if(lifetime < LifetimeBox)
  331.                     LifetimeBox = lifetime;
  332.                   break;
  333.             if(priv) LifetimeBox = lifetime;
  334.         }
  335.     }
  336.     sprintf(SaveDir, "%s%s", getenv("INFO_DIR"), BoxSName);
  337. }
  338. else{                    /* UserFIle */
  339.      if(*ZielMB == '\0'){
  340.     if((Record = readUSRInfo(BoxSName)) != NULL){
  341.         sprintf(ZielMB, "%.6s", Record->MyBBS);
  342.     }
  343.         else
  344.         sprintf(ZielMB, "%s", getenv("OWNBBS"));
  345.       }
  346.       sprintf(SaveDir, "%s%s", getenv("USR_DIR"), BoxSName);
  347. }
  348. upcase(ZielMB);
  349.  
  350. #ifdef DEBUG
  351. fprintf(stderr,
  352. "\n-----------------------------------------------------------------------\n");
  353. fprintf(stderr, "Zeile %d:\n", __LINE__);
  354. fprintf(stderr,
  355.     "Call   : %-6s SendCall : %-6s BoxSn : %-8s OrgSn       : %-8s\n",
  356.                             Call,
  357.                         SendCall,
  358.                         BoxSName,
  359.                         OrgSName);
  360. fprintf(stderr, "ZielMB : %-6s BullID   : %-13s           LifetimeBox : %-4d\n",
  361.                                 ZielMB,
  362.                                 BullID,
  363.                                 LifetimeBox);
  364. fprintf(stderr,
  365. "-----------------------------------------------------------------------\n");
  366. #endif
  367.  
  368. memset(ChanStr, ' ', 80);
  369. fprintf(Tmp_fp, "\n\031%58.58s\n", ChanStr);        /* Space for Headline */
  370. fprintf(Tmp_fp, "%-.79s\n", Subject);
  371. if(isCall(BoxSName) == 0)                    /* Info */
  372.    fprintf(Tmp_fp, "*** Bulletin-ID: %s ***\n", BullID);
  373. else
  374.    fprintf(Tmp_fp, "\n");
  375.  
  376. *ChanStr = '\0';
  377. #ifndef KEYB
  378.   fp_pos = ftell(Imp_fp);
  379.   fgets(ChanStr, 80, Imp_fp);
  380.   fseek(Imp_fp, fp_pos, 0);
  381. #endif
  382.  
  383. if(strncmp(ChanStr, "R:", 2) == 0){
  384.    ptr = strchr(ChanStr, '@');
  385.    while(!isalnum(*ptr++));
  386.    ptr --;
  387.    sscanf(ptr, "%6s", RecFrom);
  388.    fprintf(Tmp_fp, "*** Received from %s ***\n\n", RecFrom);
  389. }
  390. else{
  391.    fprintf(Tmp_fp, "\n\nde %s @ %s\n\n", SendCall, getenv("OWNBBS"));
  392. }
  393.  
  394. /* Text in TMP-file einlesen */
  395. fprintf(stderr, "%s %s %c%s", GetMsg(18, Lang),    /* Bitte Text eingeben */
  396.              BoxSName,
  397.             *ZielMB ? '@' : '\0',
  398.             ZielMB);
  399. fprintf(stderr, "%s\n", GetMsg(19, Lang));
  400.  
  401. if(get_text(Tmp_fp, Imp_fp, TmpFilename, ImpPath) < 0){
  402.     fprintf(stderr, "%s\n",GetMsg(3, Lang));
  403.     fclose(Tmp_fp);
  404.     #ifndef DEBUG
  405.      unlink(TmpFilename);
  406.         #endif
  407.     exit(0);
  408. }
  409.  
  410.  
  411. fseek(Tmp_fp, 0l, 2);
  412. bytecount = ftell(Tmp_fp);
  413. glob_bytecount += bytecount;
  414. fseek(Tmp_fp, 3l,0);
  415. fprintf(Tmp_fp, "%-.8s", BoxSName);
  416. if(*ZielMB == '\0')
  417.   fprintf(Tmp_fp, " @%-.6s", getenv("OWNBBS"));
  418. else
  419.   fprintf(Tmp_fp, " @%-.6s", ZielMB);
  420. time(&utc_secs);
  421. utc = gmtime(&utc_secs);
  422. fseek(Tmp_fp, 20l, 0);
  423. fprintf(Tmp_fp, "de:%-7.6s%02d.%02d.%02d %02d:%02d", SendCall,
  424.                                   utc->tm_mday,
  425.                                  utc->tm_mon+1,
  426.                                  utc->tm_year,
  427.                              utc->tm_hour,
  428.                              utc->tm_min);
  429. if(isCall(BoxSName))
  430.     fprintf(Tmp_fp, " %3.3s", "UTC");
  431. else
  432.    fprintf(Tmp_fp, " %3d", LifetimeBox);
  433. fprintf(Tmp_fp, " %6ld Bytes", bytecount);
  434. fclose(Tmp_fp);
  435.  
  436.  
  437. sprintf(ChanStr, "%s\\protfile.dat", SaveDir);
  438. if((Prot_fp = fopen(ChanStr, "r+")) == NULL){
  439.     mkdir(SaveDir);
  440.     sprintf(ChanStr, "%s\\protfile.dat", SaveDir);
  441.     Prot_fp = fopen(ChanStr, "w");
  442.     fclose(Prot_fp);   /* einen NullByteFile erzeugen */
  443.     Prot_fp = fopen(ChanStr, "r+");   /* oeffnen fuer read & write */
  444. }
  445. sprintf(ChanStr, "%s\\", SaveDir);
  446. mktmp(ChanStr);
  447. upcase(ChanStr);
  448. #ifdef DEBUG
  449. fprintf(stderr, "\nZeile %d: %s\n", __LINE__, ChanStr);
  450. #endif
  451.  
  452. _fmode= O_BINARY;
  453. Tmp_fp= fopen(TmpFilename, "rb");
  454. fp = fopen(ChanStr, "wb");
  455. while ((bytes=fread(MultiBuff, 1, sizeof(MultiBuff), Tmp_fp)) > 0)
  456.           fwrite(MultiBuff, 1, bytes, fp);
  457. fclose(Tmp_fp);
  458. fclose(fp);
  459. #ifndef DEBUG
  460.  unlink(TmpFilename);
  461. #endif
  462. _fmode= O_TEXT;
  463. fseek(Prot_fp, 0l, 2);  /* auf das Ende von Protfile positionieren */
  464.  
  465.  fp_pos = ftell(Prot_fp);
  466.  fseek(Prot_fp, fp_pos, 0);
  467.  if (fp_pos < IDXLENGTH-1) {   /* betr. nur eine unvollstaendige */
  468.     fp_pos = 0;            /* erste Zeile - loeschen */
  469.     fseek(Prot_fp, fp_pos, 0);
  470.  }
  471.  c = '\0';
  472.  if(fp_pos > 0){
  473.      for( ; c != '\n' &&
  474.             c != '\032' &&
  475.         ftell(Prot_fp) !=0 &&
  476.             c != '!'&& c != '|'; ){
  477.                 c = (char)fgetc(Prot_fp);
  478.             fp_pos --;
  479.             fseek(Prot_fp, fp_pos, 0);
  480.      }
  481.       fp_pos += 2;
  482.       fseek(Prot_fp, fp_pos, 0);
  483.     if(c == '!' || c == '|')
  484.         fprintf(Prot_fp, "\n");
  485.  }
  486. #ifdef DEBUG
  487. fprintf(stderr,
  488. "-----------------------------------------------------------------------\n");
  489. fprintf(stderr, "Zeile %d\n",  __LINE__);
  490. fprintf(stderr, "Sendcall: %-6s Bytecount: %5ld BinFlag: %1d\n",
  491.                 SendCall, bytecount, BinFlag);
  492. fprintf(stderr, "Subject : %s\n", Subject);
  493. fprintf(stderr,
  494. "-----------------------------------------------------------------------\n");
  495. #endif
  496. fprintf(Prot_fp,
  497.            /*     Date    */ /*  time */
  498.  "%s%-6.6s %2.2d.%2.2d.%2.2d %2.2d.%2.2d %6ld",
  499.                         ChanStr+strlen(SaveDir)+1,
  500.                         SendCall,
  501.                         utc->tm_mday,
  502.                         utc->tm_mon+1,
  503.                         utc->tm_year%100,
  504.                         utc->tm_hour,
  505.                         utc->tm_min,
  506.                         bytecount);
  507.  
  508.  
  509. if(BinFlag)
  510.    fprintf(Prot_fp, "  (BIN) %-70.70s!\n", Subject);
  511. else
  512.    fprintf(Prot_fp, "  %-76.76s!\n", Subject);
  513. fseek(Prot_fp, 0l, 2);
  514. No =(int)(ftell(Prot_fp)/IDXLENGTH+1)-1;
  515. fclose(Prot_fp);
  516.  
  517. if(strcmp(ZielMB, getenv("OWNBBS")))
  518.     Mk_SFRec(BoxSName, No, SendCall, BullID,
  519.          ZielMB, lifetime,OrgSName, bytecount, Lang);
  520.  
  521. if(isCall(BoxSName) == 0){
  522.   sprintf(ChanStr, "%sbullid.txt", getenv("MBSYS_DIR"));
  523.   fp = fopen(ChanStr, "r+");
  524.   fseek(fp, 0l, 2);
  525.   fp_pos = ftell(fp);
  526.   fseek(fp, fp_pos, 0);
  527.   c = '\0';
  528.   if(fp_pos > 0){
  529.     for( ; c != '\n' &&
  530.            c != '\032' &&
  531.            ftell(fp) !=0 &&
  532.            c != '!'&& c != '|'; ){
  533.             c = (char)fgetc(fp);
  534.                 fp_pos --;
  535.                 fseek(fp, fp_pos, 0);
  536.         }
  537.         fp_pos += 2;
  538.         fseek(fp, fp_pos, 0);
  539.         if(c == '!' || c == '|')
  540.             fprintf(fp, "\n");
  541.     }
  542.  
  543.   fprintf(fp, " %-15.15s!\n", BullID);
  544.   fclose(fp);
  545.  
  546.   memset(ShowRec+9, '.', 12);
  547.   sprintf(ShowRec,
  548.      "%-6.6s%3.3s%-8.8s%4d %08lX %-6.6s %5ld",
  549.      SendCall,
  550.      " > ",
  551.      BoxSName,
  552.      No,
  553.      (utc_secs-BoxNullTime) /60,
  554.      ZielMB,
  555.      bytecount);
  556.  if(BinFlag)
  557.     sprintf(ShowRec+43, "  (BIN) %-19.19s%-12.12s%3d\n",  Subject,
  558.                                        BullID,
  559.                                   LifetimeBox);
  560.  else
  561.     sprintf(ShowRec+43, "  %-25.25s%-12.12s%3d\n", Subject,
  562.                                 BullID,
  563.                            LifetimeBox);
  564.  for(i = 9; i < 20; i++)
  565.     if(ShowRec[i] == ' ') ShowRec[i] = '.';
  566.  sprintf(ChanStr, "%sshow.box", getenv("MBSYS_DIR"));
  567.  if((fp=fopen(ChanStr, "r+")) == NULL){
  568.           fp = fopen(ChanStr, "w");
  569.       fclose(fp);
  570.       fp=fopen(ChanStr, "r+");
  571.  
  572.  }
  573.  fseek(fp, 0l, 2);
  574.  fp_pos = ftell(fp);
  575.  fseek(fp, fp_pos, 0);
  576.  if (fp_pos < ShowLength-1) {   /* betr. nur eine unvollstaendige */
  577.     fp_pos = 0;             /* erste Zeile - loeschen */
  578.     fseek(fp, fp_pos, 0);
  579.  }
  580.  c = '\0';
  581.  if(fp_pos > 0){
  582.     for( ; c != '\n' &&
  583.            c != '\032' &&
  584.            ftell(fp) !=0; ){
  585.             c = (char)fgetc(fp);
  586.                 fp_pos --;
  587.                 fseek(fp, fp_pos, 0);
  588.         }
  589.         fp_pos += 2;
  590.         fseek(fp, fp_pos, 0);
  591.     }
  592.  
  593.  fputs(ShowRec, fp);
  594.  fclose(fp);
  595. }  /*if iscall == 0 */
  596. }
  597.  
  598.  
  599. char *ConvName(SName)
  600. char *SName;
  601. {
  602. char ChanStr[80];
  603. char in[20];
  604. static char out[20];
  605.  
  606. FILE *Conv_fp;
  607.  
  608.  
  609. sprintf(ChanStr, "%sconvname.box", getenv("MBSYS_DIR"));
  610. if((Conv_fp = fopen(ChanStr, "r")) != NULL)
  611. while(fgets(ChanStr, 79, Conv_fp) != NULL){
  612.     upcase(ChanStr);
  613.     sscanf(ChanStr, "%s %s", in, out);
  614.     if(strcmp(in, SName) == 0){
  615.         out[9] = '\0';
  616.         fclose(Conv_fp);
  617.         return &out[0];
  618.     }
  619. }
  620. fclose(Conv_fp);
  621. return NULL;
  622. }
  623.  
  624. int isCall(Call)
  625. unsigned char *Call;
  626. {
  627.  int ok;
  628.  int length;
  629.  int count;
  630.  char *uc;
  631.  
  632.  length = strlen(Call);
  633.  
  634.  /*printf("Laenge ");*/
  635.  if((length > 2) && (length < 7))
  636.  ok = 1;
  637.  else ok = 0;
  638.  
  639.  if(Call[0] > 0x7F) ok = 0;
  640.  
  641.  if(ok == 1)
  642.  {
  643.   /*printf("Zahlen 2+3 ");*/
  644.   if((isdigit(*(Call +1))) || (isdigit(*(Call +2)))) ok = 1;
  645.   else ok = 0;
  646.  }
  647.  
  648.  if(ok == 1)
  649.  {
  650.   /*printf("Letztes keine Zahl ");*/
  651.   if(!isdigit(*(Call + length -1))) ok = 1;
  652.   else ok = 0;
  653.  }
  654.  
  655.  if(ok == 1)
  656.  {
  657.   /*printf("Suffix-Length ");*/
  658.   uc = Call + length ;
  659.   count = 0;
  660.  
  661.   do
  662.   {
  663.    uc -= 1;
  664.    count++;
  665.   }
  666.   while((count < 5) && (isdigit(*uc) == 0));
  667.  
  668.   if(count < 5) ok = 1;
  669.   else ok = 0;
  670.  }
  671.  
  672.  if(ok == 1)
  673.  {
  674.   /*printf("Zahlen 1+2 ");*/
  675.   uc = Call;
  676.   if((isdigit(*uc++))&&(isdigit(*uc))) ok = 0;
  677.   else ok = 1;
  678.  }
  679.  
  680.  return(ok);
  681. }
  682.  
  683.  
  684.  
  685.  
  686.  
  687. char *genBullID()
  688. {
  689.  time_t time_now;
  690.  int CC;
  691.  int OM;
  692.  char CCC[80];
  693.  char ChanStr[80];
  694.  char BullID[20];
  695.  char OldBullID[80];
  696.  
  697.  FILE *Bull_fp;
  698.  struct tm *UTC;
  699.  
  700.  time(&time_now);
  701.  UTC = gmtime(&time_now);
  702.  sprintf(ChanStr,"%sbullid.txt",getenv("MBSYS_DIR"));
  703.  Bull_fp = fopen(ChanStr, "r+");
  704.  if (Bull_fp == NULL){
  705.     sprintf(OldBullID,"000000000000");
  706.     Bull_fp = fopen(ChanStr, "w");
  707.  }
  708.  else
  709.     if(fgets(OldBullID, 19, Bull_fp) == NULL)
  710.     sprintf(OldBullID,"000000000000");
  711.  fseek(Bull_fp, 0l, 0);
  712.  *(OldBullID+13) = '\0';
  713.  sscanf(OldBullID + 5,"%2x",&CC);
  714.  sscanf(OldBullID + 1,"%2d",&OM);
  715.  if(OM != UTC->tm_mday) CC = 0;
  716.  
  717.  CC++;
  718.  
  719.  sprintf(CCC,"%2x",CC & 0x00FF);
  720.  if(*CCC == ' ') *CCC = '0';
  721.  
  722.  sprintf(BullID,"%2d%1x%1.1d%s%s", UTC->tm_mday,
  723.                  UTC->tm_mon+1,
  724.                  UTC->tm_year%10,
  725.                  CCC,
  726.                  getenv("OWNBBS"));
  727.  upcase(BullID);
  728.  if(*BullID == ' ') *BullID = '0';
  729.  
  730.  fprintf(Bull_fp," %-15.15s!\n",BullID);
  731.  
  732.  fclose(Bull_fp);
  733.  return BullID;
  734. }
  735.  
  736.  
  737. int getLifetime(Filename)
  738. char *Filename;
  739. {
  740. int DefLTime;
  741. int Lifetime;
  742. int RubricLf;
  743. char ChanStr[80];
  744. char Rubric[15];
  745.  
  746. FILE *Lf_fp;
  747.  
  748. DefLTime = 7;
  749. Lifetime = 32000;
  750.  
  751. sprintf(ChanStr, "%slifetime.box", getenv("MB_DIR"));
  752. Lf_fp = fopen(ChanStr, "r");
  753. while(fgets(ChanStr, 80, Lf_fp) != NULL){
  754.         sscanf(ChanStr, "%8s %3d", Rubric, &RubricLf);
  755.     if(strcmp(Rubric, "*") == 0) DefLTime = RubricLf;
  756.  
  757.          if(strcmp(upcase(Rubric), upcase(Filename)) == 0){
  758.         Lifetime = RubricLf;
  759.         break;
  760.      }
  761. }
  762. fclose(Lf_fp);
  763. if (Lifetime == 32000)
  764.     return DefLTime;
  765. else
  766.    return Lifetime;
  767. }
  768.  
  769.  
  770.  
  771.  
  772. mktmpnam(Zeile)
  773. char *Zeile;
  774. {
  775.  unsigned char *c;
  776.  static unsigned int now = 0;
  777.  int i;
  778.  
  779.  c = Zeile + strlen(Zeile);
  780.  
  781.  srand(now++);
  782.  
  783.  for (i=0;i<6;i++)
  784.  {
  785.   do
  786.    *c = (char)rand();
  787.   while((*c < 'a') || (*c > 'z'));
  788.   c++;
  789.  }
  790.  *c = '\0';
  791. }
  792.  
  793. mktmp(Name)
  794. char *Name;
  795. {
  796.  unsigned char Dummy[81];
  797.  
  798.  do
  799.  {
  800.   sprintf(Dummy,"%-.80s",Name);
  801.   mktmpnam(Dummy);
  802.  }
  803.  while (access(Dummy, AEXISTS) == 0);
  804.  sprintf(Name,"%s",Dummy);
  805. }
  806.  
  807.  
  808.  
  809.  
  810. Mk_SFRec(SName, ContPos, Call, BullID, ZielMB, Lifetime, orgname, bytecount, Lang)
  811. char *SName;
  812. int ContPos;
  813. char *Call;
  814. char *BullID;
  815. char *ZielMB;
  816. int Lifetime;
  817. char *orgname;
  818. long bytecount;
  819. char *Lang;
  820. {
  821.  char ChanStr[80];
  822.  char Zeile[SFLength+1];
  823.  char DestStr[25];
  824.  char *ptr;
  825.  char LFStr[25];
  826.  char SearchStr1[10];
  827.  char SearchStr2[10];
  828.  int sfw_fd;
  829.  int bytes;
  830.  int i;
  831.  int found;
  832.  int denied;
  833.  long DTime;
  834.  char *p;
  835.  
  836.  struct SF_DIR *sf;
  837.  
  838.  #ifdef DEBUG
  839.    fprintf(stderr, "\nZeile %d: MK_SFREC()\n", __LINE__);
  840.  #endif
  841.  
  842.  found = 0;
  843.  if((Lifetime != 32000)&&(!isCall(SName)))
  844.    sprintf(LFStr, "%d", Lifetime);
  845.  else
  846.    sprintf(LFStr, "    ");
  847.  DTime=absDat();
  848.  while(DTime >= 999) DTime -= 999;
  849.  sprintf(Zeile,
  850.   "%-9.9s%4d %-6.6s %-12.12s %-31.31s%4.4s%4ld%-8.8s%c",
  851.   SName,
  852.   ContPos,
  853.   Call,
  854.   BullID,
  855.   ZielMB,
  856.   LFStr,
  857.   DTime,
  858.   orgname,
  859.   BinFlag?'|':'!'
  860.   );
  861.  sprintf(DestStr, "--------------------");
  862.  
  863.  for( ; ((sf = get_mb()) != NULL); )
  864.         if(isCall(sf->mb)){
  865.     sprintf(ChanStr, "%s%s.sfw", getenv("MBSYS_DIR"), sf->mb);
  866.     if((sfw_fd = open(ChanStr, O_RDONLY)) > 0){
  867.          bytes = read(sfw_fd, MultiBuff, 2700);
  868.              close(sfw_fd);
  869.          *(MultiBuff+bytes+1) = '\0';
  870.          upcase(MultiBuff);
  871.          denied = 0;
  872.  
  873.          sprintf(SearchStr1, " *%s ", SName);
  874.          sprintf(SearchStr2, "\n*%s ", SName);
  875.          if(strstr(MultiBuff, SearchStr1) != NULL ||
  876.                 strstr(MultiBuff, SearchStr2) != NULL ||
  877.         strncmp(MultiBuff, SearchStr1+1, strlen(SearchStr1+1)) == 0)
  878.                                  denied = 1;
  879.  
  880.               sprintf(ChanStr, "%s", ZielMB);
  881.           for(ptr = &ChanStr[0];
  882.          (*ptr != '\0')&&(*ptr != '.')&&(*ptr != ' ');
  883.           ptr++);
  884.           *ptr = '\0';
  885.           sprintf(SearchStr1, " ~%.10s ", ChanStr);
  886.           sprintf(SearchStr2, "\n~%.10s ", ChanStr);
  887.           if(strstr(MultiBuff, SearchStr1) != NULL ||
  888.                  strstr(MultiBuff, SearchStr2) != NULL ||
  889.          strncmp(MultiBuff, SearchStr1+1, strlen(SearchStr1+1)) == 0)
  890.                                             denied = 1;
  891.           if(denied == 0){   /* keine Sperre */
  892.             sprintf(ChanStr, "%s", ZielMB);
  893.             for(ptr = &ChanStr[0];
  894.           (*ptr != '\0')&&(*ptr != '.')&&(*ptr != ' ');
  895.            ptr++);
  896.         *ptr = '\0';
  897.                 for(i=strlen(ChanStr)-1; i >= 0 && found == 0; i--){
  898.            sprintf(SearchStr1, " %.10s ", ChanStr);
  899.            sprintf(SearchStr2, "\n%.10s ", ChanStr);
  900.             if(strstr(MultiBuff, SearchStr1)||
  901.               strstr(MultiBuff, SearchStr2)||
  902.               strncmp(MultiBuff,SearchStr1+1,strlen(SearchStr1+1))==0){
  903.                     found = 1;
  904.  
  905.               if(bytecount > GetMaxBytes(sf->mb))
  906.                  *(DestStr+sf->pos) = '+';
  907.                     else
  908.                      *(DestStr+sf->pos) = 'X';
  909.              }  /* if str... */
  910.              *(ChanStr+i) = '?';
  911.              *(ChanStr+i+1) = '\0';
  912.                }  /* for strlen ...*/
  913.           }/* if !denied ...*/
  914.       } /* if sfw_fd > 0*/
  915.  }  /* if d.d_ino .... */
  916.  
  917.  if(found == 0){
  918.     write_sf("????????????????????", Zeile);
  919.     fprintf(stderr, "%s\n", GetMsg(59, Lang));
  920.  }
  921.  else{
  922.     write_sf(DestStr, Zeile);
  923.     fprintf(stderr, "%s %s @%s\n", GetMsg(2, Lang), SName, ZielMB);
  924.  }
  925. }
  926.  
  927.  
  928. struct SF_DIR *get_mb()
  929. {
  930.  char ChanStr[80];
  931.  static long pos = 0;
  932.  static struct SF_DIR sf;
  933.  static count = 0;
  934.  
  935.  FILE *fp;
  936.  
  937.  
  938.  sprintf(ChanStr, "%ssf-liste.sfw", getenv("MBSYS_DIR"));
  939.  if((fp=fopen(ChanStr, "r")) == NULL){
  940.     perror("get_mb(): sf-liste.sfw");
  941.     exit(1);
  942.   }
  943.   memset(&sf, '\0', sizeof(struct SF_DIR));
  944.   fseek(fp, 46*pos, 0);
  945.   if(fgets(ChanStr, 50, fp) == NULL || pos == 20l){
  946.         pos = 0;
  947.         fclose(fp);
  948.         return NULL;
  949.  
  950.   }
  951.   sscanf(ChanStr, "%s", sf.mb);
  952.   sf.pos = (int)pos++;
  953.  
  954.  fclose(fp);
  955.  return &sf;
  956. }
  957.  
  958.  
  959. write_sf(DestStr, Zeile)
  960. char *DestStr;
  961. char *Zeile;
  962. {
  963.  char ChanStr[80];
  964.  long fp_pos;
  965.  char c = '\0';
  966.  
  967.  
  968.  FILE *SFW_fp;
  969.  
  970.  sprintf(ChanStr, "%slogsfw.box", getenv("MBSYS_DIR"));
  971.  #ifdef DEBUG
  972.    fprintf(stderr,
  973.    "-----------------------------------------------------------------------\n");
  974.    fprintf(stderr, "Zeile %d:\n", __LINE__);
  975.    fprintf(stderr, "%s%.40s\n", DestStr, Zeile);
  976.    fprintf(stderr, "%s\n", Zeile+34);
  977.    fprintf(stderr,
  978.    "-----------------------------------------------------------------------\n");
  979.  #endif
  980.  if((SFW_fp= fopen(ChanStr, "r+")) == NULL){
  981.      if((SFW_fp= fopen(ChanStr, "w")) == NULL){
  982.        fprintf(stderr, "%s ", ChanStr);
  983.        perror("LOGSFW.BOX");
  984.        exit(1);
  985.      }
  986.     fclose(SFW_fp);
  987.     SFW_fp = fopen(ChanStr, "r+");
  988.   }
  989.   if(SFW_fp != NULL){
  990.     fseek(SFW_fp, 0l, 2);    /* Dateiende suchen */
  991.     fp_pos = ftell(SFW_fp);
  992.     fseek(SFW_fp, fp_pos, 0);
  993.     if (fp_pos < SFLength-1) {   /* betr. nur eine unvollstaendige */
  994.         fp_pos = 0;          /* erste Zeile - loeschen */
  995.         fseek(SFW_fp, fp_pos, 0);
  996.     }
  997.     if(fp_pos > 0){
  998.         for( ; c != '\n' &&
  999.                c != '\032' &&
  1000.                ftell(SFW_fp) !=0 &&
  1001.                c != '!'&& c != '|'; ){
  1002.                     c = (char)fgetc(SFW_fp);
  1003.                 fp_pos --;
  1004.                 fseek(SFW_fp, fp_pos, 0);
  1005.         }
  1006.         fp_pos += 2;
  1007.         fseek(SFW_fp, fp_pos, 0);
  1008.         if(c == '!' || c == '|')
  1009.             fprintf(SFW_fp, "\n");
  1010.     }
  1011.     fprintf(SFW_fp, "%s%s\n", DestStr, Zeile);   /* wegschreiben */
  1012.         fclose(SFW_fp);
  1013.   }
  1014. }
  1015.  
  1016.  
  1017. long GetMaxBytes(SF_MB)
  1018. char *SF_MB;
  1019. {
  1020. char ChanStr[80];
  1021. char dummy[20];
  1022. long MaxBytes = 0x7FFFFFFFl;
  1023.  
  1024. FILE *cfg_fp;
  1025.  
  1026.  
  1027. sprintf(dummy, "%s", SF_MB);
  1028. *(strchr(dummy, '.')) = '\0';
  1029. sprintf(ChanStr, "%s/%s.cfg", getenv("MBSYSDIR"), dummy);
  1030. if((cfg_fp = fopen(ChanStr, "r")) != NULL){
  1031.    fgets(ChanStr, 79, cfg_fp);
  1032.    sscanf(ChanStr, "%ld", &MaxBytes);
  1033.    MaxBytes *= 1024l;
  1034.    fclose(cfg_fp);
  1035. }
  1036. return MaxBytes;
  1037. }
  1038.  
  1039.  
  1040.  
  1041. /*
  1042.  * Convert a string to upper case.
  1043.  */
  1044. char *
  1045. upcase(s)
  1046. char *s;
  1047. {
  1048.     register char *p, c;
  1049.  
  1050.     for(p = s; c = *p; p++)
  1051.         if((c >= 'a') && (c <= 'z'))
  1052.             *p = c + 'A' - 'a';
  1053.     return(s);
  1054. }
  1055.  
  1056.  
  1057. /*
  1058.  * Convert a string to lower case.
  1059.  */
  1060. char *
  1061. lcase(s)
  1062. char *s;
  1063. {
  1064.     register char *p, c;
  1065.  
  1066.     for(p = s; c = *p; p++)
  1067.         if((c >= 'A') && (c <= 'Z'))
  1068.             *p = c + 'a' - 'A';
  1069.     return(s);
  1070. }
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.  
  1077.  
  1078. struct userrec *readUSRInfo(Call)
  1079. char *Call;
  1080. {
  1081.  struct userindex *Index;
  1082.  static struct userrec Record, *RecPtr;
  1083.  
  1084.  if((Index = (struct userindex *)getIndex(Call)) > NULL)
  1085.  {
  1086.   RecPtr = &Record;
  1087.   memset(RecPtr, '\0', sizeof(struct userrec));
  1088.   getRecord(Index, RecPtr);
  1089.   RecPtr->Status &= 0x7F;
  1090.   return RecPtr;
  1091.  }
  1092.  else return NULL;
  1093. }
  1094.  
  1095.  
  1096.  
  1097.  
  1098.  
  1099. struct userindex *getIndex(call)
  1100. char *call;
  1101. {
  1102.  int found,IFile;
  1103.  struct userindex *USRIDX;
  1104.  char dummycall[10], ChanStr[80];
  1105.  int Count,Menge;
  1106.  
  1107.  sprintf(dummycall,"%-6.6s",call);
  1108.  found  = 0;
  1109.  Menge  = 12000;
  1110.  
  1111.  sprintf(ChanStr,"%suser3.idx",getenv("MBSYS_DIR"));
  1112.  if((IFile = open(ChanStr,O_RDWR|O_BINARY)) == -1){
  1113.     perror("IFile");
  1114.     return NULL;
  1115.  }
  1116.  
  1117.  do{
  1118.       Menge = read(IFile,MultiBuff,10200);
  1119.       Count = Menge;
  1120.       if(Menge >= 12){
  1121.          USRIDX = (struct userindex *)MultiBuff;
  1122.          while((Count > 0) && (found == 0)){
  1123.            if(strncmp(USRIDX->call, dummycall,6) == 0){
  1124.                   found = 1;
  1125.                   close(IFile);
  1126.                   return USRIDX;
  1127.                }
  1128.                USRIDX++;
  1129.                Count -= 12;
  1130.          }
  1131.       }
  1132.  } while((found == 0) && (Menge == 10200));
  1133.  close(IFile);
  1134.  return NULL;
  1135. }
  1136.  
  1137.  
  1138. getRecord(Index, Record)
  1139. struct userindex *Index;
  1140. struct userrec *Record;
  1141. {
  1142.  int UserFile;
  1143.  char ChanStr[80];
  1144.  
  1145.  sprintf(ChanStr,"%s/user3.dat", getenv("MBSYS_DIR"));
  1146.  
  1147.  do
  1148.   UserFile = open(ChanStr, O_RDWR|O_BINARY);
  1149.  while(UserFile == -1);
  1150.  
  1151.  lseek(UserFile,Index->pos,0);
  1152.  read(UserFile, Record, sizeof(struct userrec));
  1153.  if(strncmp(Record->MyBBS, "OwnBBS",6) == 0)
  1154.               sprintf(Record->MyBBS, "%s", getenv("OWNBBS"));
  1155.  upcase(Record->MyBBS);
  1156.  close(UserFile);
  1157.  
  1158. }
  1159.  
  1160.  
  1161.  
  1162.  
  1163.  
  1164. char *GetMsg(MsgNo, Lang)
  1165. int MsgNo;
  1166. char *Lang;
  1167. {
  1168. int i;
  1169.  
  1170. char Filename[80];
  1171. static char msg[255];
  1172.  
  1173. FILE *stream;
  1174.  
  1175. sprintf(Filename, "%s/msg%s.box", getenv("MBSYS_DIR"), Lang);
  1176. stream = fopen(Filename, "r");
  1177. if(stream != NULL){
  1178.   for (i = 1; (fgets(msg, 255, stream) != NULL)&&(i != MsgNo); i++);
  1179.   fclose(stream);
  1180.   *(msg+strlen(msg)-1) = '\0';
  1181.   return (&msg[0]);
  1182. }
  1183. perror("GetMsg");
  1184. return NULL;
  1185. }
  1186.  
  1187.  
  1188. help()
  1189. {
  1190. fprintf(stdout, "\n                         *** HELP ***\n\n");
  1191. fprintf(stdout, "Auruf: impmsg <Importfile>\n\n");
  1192. fprintf(stdout, "Der Importfile solte folgendermassen aufgebaut sein:\n");
  1193. fprintf(stdout, "----------------------------------------------------\n");
  1194. fprintf(stdout, "s Call @ZielMB <Options>\n");
  1195. fprintf(stdout, "Titel\n");
  1196. fprintf(stdout, "\nNun kommt der Text!\n");
  1197. fprintf(stdout, "\n<eol>***END<eol>, <eol>#BIN##BinFilename<eol>\n");
  1198. fprintf(stdout, "<eol>#TXT##TextFilename<eol>\n");
  1199. fprintf(stdout, "-----------------------------------------------------\n");
  1200. fprintf(stdout, "#BIN##BinFilename ist der Befehl zum Import eines Binaerfiles.\n");
  1201. fprintf(stdout, "#BIN##TextFilename ist der Befehl zum Import eines Textfiles.\n");
  1202. fprintf(stdout, "\nCall: Call oder Rubirk.\n");
  1203. fprintf(stdout, "@ZielMB muss nicht mit angeben werden!\n");
  1204. fprintf(stdout, "\nOptions: $BullID #Lifetime <Call.\n");
  1205. fprintf(stdout, "Jede Option muss durch ein Blank (Zwischenraum) vom vorherigen Block getrennt\n");
  1206. fprintf(stdout, "werden!\n");
  1207.  
  1208. exit(0);
  1209.  
  1210. }
  1211.  
  1212.  
  1213. int Schaltjahr(Jahr)
  1214. unsigned int Jahr;
  1215. {
  1216.  if(Jahr % 4 == 0 && Jahr % 100 != 0 || Jahr % 400 == 0) return(1);
  1217.  return(0);
  1218. }
  1219.  
  1220.  
  1221.  
  1222. unsigned long absDat()
  1223. {
  1224.  struct tm *utc;
  1225.  time_t utc_secs;
  1226.  unsigned long  NumJahr;
  1227.  unsigned long  result;
  1228.  unsigned int   Mon;
  1229.       int   i;
  1230.  
  1231.  
  1232.  time(&utc_secs);
  1233.  utc=gmtime(&utc_secs);
  1234.  
  1235.  NumJahr = (long)utc->tm_year + 1900;
  1236.  for (i=1987,result=0L;i<NumJahr;i++)
  1237.  {
  1238.   if(Schaltjahr(i)) result += 366;
  1239.   else result += 365;
  1240.  }
  1241.  
  1242.  for(i=1; i < utc->tm_mon+1; i++)
  1243.  {
  1244.   switch(i)
  1245.   {
  1246.    case  1:
  1247.    case  3:
  1248.    case  5:
  1249.    case  7:
  1250.    case  8:
  1251.    case 10:
  1252.    case 12: Mon = 31;
  1253.          break;
  1254.    case  2: if(Schaltjahr((unsigned int)NumJahr)) Mon = 29; else Mon = 28;
  1255.            break;
  1256.    default: Mon = 30;
  1257.          break;
  1258.   }
  1259.   result += Mon;
  1260.  }
  1261.  
  1262.  result  += utc->tm_mday;
  1263.  
  1264.  return(result - 1);
  1265. }
  1266.  
  1267.  
  1268.  
  1269. int get_text(Tmp_fp, Imp_fp, TmpFilename, ImpPath)
  1270. FILE *Tmp_fp;
  1271. FILE *Imp_fp;
  1272. char *TmpFilename;  /* wird fuer Umchalten BIN / Text benoetigt */
  1273. char *ImpPath;
  1274. {
  1275. unsigned get_bin();
  1276. unsigned crc;
  1277. char *ptr;
  1278. char ChanStr[80];
  1279. char BinFilename[80];
  1280. char TXT_Filename[80];
  1281.  
  1282.  
  1283. long bytecount = 0l;
  1284. long TmpCRCPos;
  1285. long len;
  1286.  
  1287. FILE *bin_fp;
  1288. FILE *txt_fp;
  1289.  
  1290. int found;
  1291. int bytes;
  1292.  
  1293. ptr = &MultiBuff[0];
  1294. memset(MultiBuff, '\0', sizeof(MultiBuff));
  1295. for( ; ; ){
  1296.         found = 0;
  1297.     if((*ptr = (char)getc(Imp_fp)) > '\0' || *ptr == -1) bytecount++;
  1298.     if((*ptr == '\032')||(*ptr == '\04')||feof(Imp_fp)){
  1299.         if(bytecount == 1l){
  1300.         return (-1);
  1301.         }
  1302.         else{
  1303.                 fwrite(MultiBuff, 1, strlen(MultiBuff)-1, Tmp_fp);
  1304.                 memset(MultiBuff, '\0', sizeof(MultiBuff));
  1305.         ptr = &MultiBuff[0];
  1306.                 fputc('\n', Tmp_fp);
  1307.         break;
  1308.         }
  1309.     }
  1310.  
  1311.         if(*ptr == '\n'){
  1312.                 /*   ***END */
  1313.         if(strncmp(MultiBuff, "***END\n", 7) == 0 ||
  1314.                    strncmp(MultiBuff, "***end\n", 7) == 0){
  1315.             if(bytecount == 7l){
  1316.                 return (-1);
  1317.                 }
  1318.                 else{
  1319.                             fwrite(MultiBuff, 1, strlen(MultiBuff)-7, Tmp_fp);
  1320.                             memset(MultiBuff, '\0', sizeof(MultiBuff));
  1321.                     ptr = &MultiBuff[0];
  1322.                 fputc('\n', Tmp_fp);
  1323.                 break;
  1324.                         }
  1325.         }   /* ***END */
  1326.  
  1327.                /* BINAER */
  1328.                if(strncmp(MultiBuff, "#BIN##", 6) == 0 ||
  1329.                   strncmp(MultiBuff, "#bin##", 6) == 0){
  1330.              found = 1;
  1331.              sscanf(MultiBuff+6, "%s", BinFilename);
  1332.                      if(*(MultiBuff+6+strlen(BinFilename)) != '\n' ||
  1333.             strlen(BinFilename) == 0){
  1334.                fwrite(MultiBuff, 1, strlen(MultiBuff), Tmp_fp);
  1335.                memset(MultiBuff, '\0', sizeof(MultiBuff));
  1336.                ptr = &MultiBuff[0];
  1337.                continue;
  1338.                }
  1339.              fputc('\n', Tmp_fp);
  1340.              fclose(Tmp_fp);
  1341.              _fmode = O_BINARY;
  1342.                     if((bin_fp = fopen(BinFilename, "rb")) == NULL){
  1343.                          sprintf(ChanStr, "%s%s", ImpPath, BinFilename);
  1344.              if((bin_fp = fopen(ChanStr, "rb")) == NULL){
  1345.                 perror("Binfile");
  1346.                 err_count++;
  1347.                 _fmode = O_TEXT;
  1348.                                 Tmp_fp = fopen(TmpFilename, "r+t");
  1349.                 fseek(Tmp_fp, 0l, 2);
  1350.                 break;
  1351.                             }
  1352.            }
  1353.            BinFlag = 1;
  1354.            Tmp_fp=fopen(TmpFilename, "r+b");
  1355.            fseek(Tmp_fp, 0l, 2);
  1356.                    fseek(bin_fp, 0l, 2);
  1357.                len = ftell(bin_fp);
  1358.            fprintf(stderr, "\n#BIN#%ld#%s\n\n", len, BinFilename);
  1359.                    fprintf(Tmp_fp, "#BIN#%ld#|", len);
  1360.                    TmpCRCPos = ftell(Tmp_fp);
  1361.            fprintf(Tmp_fp, "65535\r");
  1362.            crc = get_bin(Tmp_fp, bin_fp);
  1363.                    fseek(Tmp_fp, TmpCRCPos, 0);
  1364.            fprintf(Tmp_fp, "%5.5u", crc);
  1365.            fprintf(stderr, "#OK#%u\n\n", crc);
  1366.            fclose(bin_fp);
  1367.            fclose(Tmp_fp);
  1368.                    _fmode = O_TEXT;
  1369.            Tmp_fp = fopen(TmpFilename, "r+t");
  1370.            fseek(Tmp_fp, 0l,2);
  1371.                    break;
  1372.                }   /* #BIN## */
  1373.  
  1374.            /*  TEXT */
  1375.                    if(strncmp(MultiBuff, "#TXT##", 6) == 0 ||
  1376.                       strncmp(MultiBuff, "#txt##", 6) == 0){
  1377.                          found = 1;
  1378.                  sscanf(MultiBuff+6, "%s", TXT_Filename);
  1379.                          if(*(MultiBuff+6+strlen(TXT_Filename)) != '\n' ||
  1380.                 strlen(TXT_Filename) == 0){
  1381.                   fwrite(MultiBuff, 1, strlen(MultiBuff), Tmp_fp);
  1382.                   memset(MultiBuff, '\0', sizeof(MultiBuff));
  1383.                   ptr = &MultiBuff[0];
  1384.                   continue;
  1385.                    }
  1386.                          if((txt_fp = fopen(TXT_Filename, "rt")) == NULL){
  1387.                              sprintf(ChanStr, "%s%s", ImpPath, TXT_Filename);
  1388.                  if((txt_fp = fopen(ChanStr, "r")) == NULL){
  1389.                 perror("txt_file");
  1390.                 err_count++;
  1391.                 break;
  1392.                              }
  1393.                  }
  1394.                  fseek(txt_fp, 0l, 2);
  1395.                      len = ftell(txt_fp);
  1396.              fseek(txt_fp, 0l, 0);
  1397.              fprintf(stderr, "\n#TXT#%ld#%s\n\n", len, TXT_Filename);
  1398.                          while ((bytes=fread(MultiBuff, 1,
  1399.                              sizeof(MultiBuff), txt_fp)) > 0)
  1400.                          fwrite(MultiBuff, 1, bytes, Tmp_fp);
  1401.             fprintf(stderr, "#OK#\n\n");
  1402.             fclose(txt_fp);
  1403.                 break;
  1404.                    } /* #TXT## */
  1405.  
  1406.                    /*  DEFAULT */
  1407.            if(found == 0){
  1408.                fwrite(MultiBuff, 1, strlen(MultiBuff), Tmp_fp);
  1409.                memset(MultiBuff, '\0', sizeof(MultiBuff));
  1410.                ptr = &MultiBuff[0];
  1411.                    }
  1412.  
  1413.     }   /* if Cr or Lf */
  1414.     else{
  1415.            /* fputc(*ptr, stdout); */
  1416.         ptr++;
  1417.     }
  1418.  
  1419. }
  1420.  
  1421. return 1;
  1422. }
  1423.  
  1424.  
  1425.  
  1426.  
  1427. /*
  1428.  *   CCITT Polynom x^16 + x^12 + x^5 + 1
  1429.  *
  1430.  *   hier im Gegensatz zu CCITT, (A)X.25:
  1431.  *     - Datenbyte MSB zuerst
  1432.  *     - CRC-Start mit 0
  1433.  *     - keine Multiplikation Nachricht mit x^16
  1434.  *       (CRC wird bei Empfang nicht ueber CRC-Bytes berechnet)
  1435.  *     - kein Invertieren des CRC
  1436.  *
  1437.  *   wird z.B. benutzt von:  UoSat DCE, SEVEN
  1438.  */
  1439.  
  1440.  /* unsigned crctab[256];*/
  1441. /*  unsigned crc;  */
  1442. /*unsigned byte; */       /* Datenbyte, high Byte = 0 ! */
  1443.  
  1444.  
  1445.  
  1446. /*
  1447.  *   entweder beim Programmstart einmal aufrufen,
  1448.  *   oder die 512 Byte Tabelle einmal ausrechnen lassen und dann als
  1449.  *   initialisierte Tabelle ins Programm uebernehmen
  1450.  */
  1451.  
  1452. init_crctab()
  1453.   {
  1454.     unsigned n;
  1455.     unsigned m;
  1456.     unsigned r;
  1457.     unsigned mask;
  1458.  
  1459.     static unsigned bitrmdrs[] = { 0x9188,0x48C4,0x2462,0x1231,
  1460.                                    0x8108,0x4084,0x2042,0x1021  };
  1461.  
  1462.     for (n = 0; n < 256; ++n)
  1463.       {
  1464.         for (mask = 0x0080, r = 0, m = 0; m < 8; ++m, mask >>= 1)
  1465.           if (n & mask) r = bitrmdrs[m] ^ r;
  1466. /*
  1467.  *       "if (n & mask) r ^= bitrmdrs[m];"  ist kuerzer, aber Turbo C fuer
  1468.  *       den Atari ST, Version 1.0, uebersetzt das falsch
  1469.  */
  1470.         crctab[n] = r;
  1471.       }
  1472.   }
  1473.  
  1474.  
  1475.  
  1476. /*
  1477.  *   byteweiser Algorithmus, C, portabel
  1478.  */
  1479.           /*
  1480. void do_crc(void)
  1481.   {
  1482.     crc = crctab[crc >> 8] ^ (crc << 8 | byte);
  1483.   }
  1484.             */
  1485.  
  1486.  
  1487.  unsigned get_bin(tmp_fp, bin_fp)
  1488.  FILE *tmp_fp;
  1489.  FILE *bin_fp;
  1490.  {
  1491.   unsigned byte;
  1492.   unsigned crc = 0;
  1493.   long bytecnt;
  1494.  
  1495.  
  1496.    fseek(bin_fp, 0l, 0);
  1497.     for (bytecnt = 0l; (byte = fgetc(bin_fp)) != -1; bytecnt++){
  1498.       crc = crctab[crc >> 8] ^ ((crc << 8) | byte);
  1499.       fputc(byte, tmp_fp);
  1500.   }
  1501.  
  1502.   return crc;
  1503.  }
  1504.  
  1505. char *getpath(Filename)
  1506. char *Filename;
  1507. {
  1508.  char drive[MAXDRIVE];
  1509.  char dir[MAXDIR];
  1510.  char ext[MAXEXT];
  1511.  char name[MAXFILE];
  1512.  static char Path[MAXPATH];
  1513.  
  1514.  fnsplit(Filename, drive, dir, name, ext);
  1515.  sprintf(Path, "%s%s", drive, dir);
  1516.  
  1517.  return &Path[0];
  1518. }